package cn.tedu.truetaste.service.impl;

import cn.tedu.truetaste.ex.ServiceException;
import cn.tedu.truetaste.mapper.UserMapper;
import cn.tedu.truetaste.pojo.dto.UserAddNewDTO;
import cn.tedu.truetaste.pojo.dto.UserUpdateDTO;
import cn.tedu.truetaste.pojo.entity.User;
import cn.tedu.truetaste.pojo.vo.UserListItemVO;
import cn.tedu.truetaste.pojo.vo.UserStandardVO;
import cn.tedu.truetaste.service.IUserService;
import cn.tedu.truetaste.web.ServiceCode;
import com.alibaba.fastjson.JSON;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.security.authentication.AuthenticationManager;
//import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
//import org.springframework.security.core.Authentication;
//import org.springframework.security.core.GrantedAuthority;
//import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * 处理用户业务的实现类
 *
 * @author java@tedu.cn
 * @version 0.0.1
 */
@Slf4j
@Service
public class UserServiceImpl implements IUserService {

    @Autowired
    private UserMapper userMapper;

    public UserServiceImpl() {
        log.info("创建业务对象：UserServiceImpl");
    }

    @Override
    public void addNew(UserAddNewDTO userAddNewDTO) {
        log.debug("开始处理【添加用户信息】的业务，参数：{}", userAddNewDTO);

        {
            // 从参数对象中取出用户名
            String name = userAddNewDTO.getName();
            // 调用userMapper.countByName()执行统计
            int count = userMapper.countByName(name);
            // 判断统计结果是否大于0
            if (count > 0) {
                // 是：抛出异常（ERR_CONFLICT）
                String message = "添加用户失败，尝试使用的用户名已经被占用！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        {
            // 从参数对象中取出手机号码
            String phone = userAddNewDTO.getPhone();
            // 调用userMapper.countByPhone()执行统计
            int count = userMapper.countByPhone(phone);
            // 判断统计结果是否大于0
            if (count > 0) {
                // 是：抛出异常（ERR_CONFLICT）
                String message = "添加用户失败，尝试使用的手机号码已经被占用！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        // 创建User对象
        User user = new User();
        // 复制参数DTO对象中的属性到实体对象中
        BeanUtils.copyProperties(userAddNewDTO, user);
        // 调用userMapper.insert()方法插入用户数据
        int rows = userMapper.insert(user);
        if (rows != 1) {
            String message = "添加用户失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }
    }

    @Override
    public void delete(Long id) {
        log.debug("开始处理【删除用户】的业务，参数：{}", id);
        // 检查尝试删除的用户是否存在
        Object queryResult = userMapper.getStandardById(id);
        //Object queryResult = userMapper.getStandardByOpenId(openId);
        if (queryResult == null) {
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, "删除用户失败，尝试访问的数据不存在！");
        }

        // 执行删除
        int rows = userMapper.deleteById(id);
        if (rows != 1) {
            throw new ServiceException(ServiceCode.ERR_DELETE, "删除用户失败，服务器忙，请稍后再次尝试！");
        }
        log.debug("删除用户完成！");
    }

    @Override
    public void updateInfoById(Long id, UserUpdateDTO userUpdateDTO) {
        log.debug("开始处理【修改用户详情】的业务，参数ID：{}，新数据：{}",id, userUpdateDTO);

        {
            // 调用Mapper的getStandardById()执行查询，检查数据是否不存在
            UserStandardVO userStandardVO = userMapper.getStandardById(id);
            //UserStandardVO userStandardVO = userMapper.getStandardByOpenId(openId);
            System.out.println("---"+userStandardVO);
            // 是：数据不存在，抛出异常
            if (userStandardVO == null) {
                String message = "修改用户详情失败，尝试访问的数据不存在！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
            }
        }

        {
            // 调用Mapper的countByNameAndNotId()执行查询，检查新的名称是否已经被别的数据占用
            int count = userMapper.countByNameAndNotId(id, userUpdateDTO.getName());
            // 是：名称被别的数据占用，抛出异常（NOT_CONFLICT）
            if (count > 0) {
                String message = "修改用户详情失败，新的用户名称已经被占用！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        {
            // 调用Mapper的countByPhoneAndNotId()执行查询，检查新的手机号码是否已经被别的数据占用
            int count = userMapper.countByPhoneAndNotId(id, userUpdateDTO.getPhone());
            // 是：手机号码被别的数据占用，抛出异常（NOT_CONFLICT）
            if (count > 0) {
                String message = "修改用户详情失败，新的手机号码已经被占用！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }

        // 创建User对象
        User user = new User();
        // 将参数对象的属性值复制到以上新创建的Dishes对象中
        BeanUtils.copyProperties(userUpdateDTO, user);
        user.setId(id);
        // 调用Mapper的update(User user)方法执行修改
        log.debug("即将执行修改数据，参数：{}", user);
        int rows = userMapper.update(user);
        if (rows != 1) {
            String message = "修改用户详情失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public UserStandardVO getStandardByOpenId(String openId) {
        log.debug("开始处理【根据openId查询用户详情】的业务，参数：{}", openId);

        // 调用Mapper的getStandardByOpenId()执行查询
        UserStandardVO userStandardVO = userMapper.getStandardByOpenId(openId);
        System.out.println("---"+userStandardVO);
        // 判断查询结果是否为null
        // 是：没有匹配的数据，抛出异常（NOT_FOUND）
        if (userStandardVO == null) {
            String message = "查询用户详情失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        log.debug("即将返回查询结果：{}", userStandardVO);
        return userStandardVO;
    }

    @Override
    public UserStandardVO getStandardById(Long id) {
        log.debug("开始处理【根据id查询用户详情】的业务，参数：{}", id);

        // 调用Mapper的getStandardById()执行查询
        UserStandardVO userStandardVO = userMapper.getStandardById(id);
        // 判断查询结果是否为null
        // 是：没有匹配的数据，抛出异常（NOT_FOUND）
        if (userStandardVO == null) {
            String message = "查询用户详情失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        log.debug("即将返回查询结果：{}", userStandardVO);
        return userStandardVO;
    }

    @Override
    public List<UserListItemVO> list() {
        log.debug("开始处理【查询用户列表】的业务，参数：无");
        List<UserListItemVO> list = userMapper.list();

        /*Iterator<UserListItemVO> iterator = list.iterator();
        while (iterator.hasNext()) {
            UserListItemVO user = iterator.next();
            if (user.getId() == 1) {
                iterator.remove();
                break;
            }
        }*/
        return list;
    }
}
